Present day computer systems that use graphics displays have a number of different architectures. Some systems use a host processor and a display controller. These are essentially hard wired, bit-mapped systems that require the host processor to perform all the graphics processing. A disadvantage of such systems is that as graphics demands, such as resolution, increase, so does the processing burden on the host, which results in decreased processing speed.
As an alternative to display controllers, other systems have transferred graphics processing tasks to a graphics processor subsystem. Some such systems rely on dedicated hardware implementations of graphics functions. Other graphics processor subsystems use a programmable graphics processor, which permit a programmer to add functionality.
Although graphics processor subsystems permit higher resolution and faster execution, a disadvantage of many such systems, both hardwired and programmable, is that they are not easily extensible. Even those subsystems that have programmable processors are difficult to integrate with the host system and its application programs, and for this reason are essentially fixed function systems. Such systems attempt to be as general as possible, and tend to have a "wheel of reincarnation" effect, resulting from adding so many functions to the subsystem that functionality comes at the expense of efficiency. Another problem with systems that have a fixed set of functions, or that are difficult to extend, is that they do not keep pace with graphics software, for which new graphics algorithms are continually evolving.
In addition to extensibility, a consideration in designing graphics systems is standardization. From the hardware manufacturer's point of view, the goal of a graphics standard is to permit a graphics system to be used with many applications programs. From the software developer's point of view, a standard should permit a program to run on any graphics system. Many standards, such as the CGA, EGA, and VGA, are directed to a single processor system, rather than a graphics subprocessor system, and although they are successful in interfacing software with graphics hardware, do not provide an interface between the host and graphics system.
Thus, a need exists for a graphics subsystem interface that provides extensibility without compromising efficiency. Furthermore, the mechanisms for implementing extensibility should provide an interface to which both applications programmers and hardware manufacturers may direct their products. The interface must be sufficiently high level to encourage standardization, yet sufficiently low level to promote processing speed.